/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Miscelanea.tiposgenericos;


import Miscelanea.tiposgenericos.Persona;

import java.util.*;

/**
 *
 * @author User
 */
public class TAREA {
   
    
    
public  static class Nodo{ 

public Persona dato; 

public Nodo next; 

public Nodo(Persona n){ 

dato=n; 

next=null; 


}

        @Override
        public String toString() {
            return "Nodo{" + "dato=" + dato + '}';
        }

} 
public static class PersonasIterator implements Iterator {
    // Iterador para desplazarnos por la lista
    private final Iterator iterador;
    // Objeto de tipo Number actual
    private Persona p;

    // Constructor de la clase
    public PersonasIterator( Iterator _iterador ) {
        this.iterador = _iterador;
    }

    public boolean hasNext() {
       
        if( p != null )
            return( true );

        
        while( iterador.hasNext() ) {
            p = (Persona)iterador.next();
            if( p instanceof Persona )
                return( true );
        }

        
        p = null;
        return( false );
    }

    public Persona next() {
       
        if( p == null    &&    !hasNext() )    {
            throw new NoSuchElementException();
        }

       
        Persona objp = p;
        p = null;
        return( objp );
    }

    public void remove() {
        
        
        throw new UnsupportedOperationException();
    }
}

public  static class Lista{ 

private Nodo start; // Primer nodo de la lista

        private Lista(Nodo start) {
            this.start = start;
        }
/**
* Añade un nodo al final de la lista.
*/

private void add(Persona N){ 

Nodo aux=start;

// Si la lista esta completamente vacia
if(aux==null){ 
// Creamos el primer elemento
aux=new Nodo(N); 

}else{ 
// En caso contrario buscamos el ultimo y lo añadimos
while(aux.next!=null) aux=aux.next; 

aux.next=new Nodo(N); 

}
}

        @Override
        public String toString() {
            String cadena="";
            Nodo aux= start;
            if (start==null) {
                return "No existen Elementos";
            }
            else{
            cadena+=start + " - ";
            
            while (aux.next!=null) { 
                cadena+=aux.next + " - ";
                aux.next=aux.next.next;
                       
                
            }
             return cadena;
            }
                          
           
        }


}
public static class PersonasLinked implements Comparable<Persona>{
    
   private  Persona p;

        public PersonasLinked(Persona pp) {
            this.p = pp;
        }

        public Persona getPersona() {
            return p;
        }

        public void setListaLinked(Persona pp) {
            this.p = pp;
        }
   

        @Override
        public int compareTo(Persona o) {
            return p.getNombre().compareTo(o.getNombre());
        }



}
    public static void main(String[] args)
    {
    Set <Persona> listaDescendente = new TreeSet<Persona>();
       listaDescendente.add(new Persona("Juan",12));
       listaDescendente.add(new Persona("Alberto",34));
       listaDescendente.add(new Persona("Ivan",15));
       listaDescendente.add(new Persona("Angel",23));
       
       System.out.println("TAREA 1: LISTA DESCENDENTE: " + listaDescendente);
     
       //********************
       Set <Persona> listaEdad = new TreeSet<Persona>(new OrdenarPersonaEdad());
       listaEdad.add(new Persona("Juan",17));
       listaEdad.add(new Persona("Alberto",12));
       listaEdad.add(new Persona("Ivan",10));
       listaEdad.add(new Persona("Angel",43));
       
       System.out.println("TAREA 2: LISTA ORDENADA POR EDAD: "+ listaEdad);
       
       //******************* 
       // Implementar una lista enlazada utilizando tipos genéricos.
       Lista enlazada= new Lista(new Nodo(new Persona("Rosa",16)));
       enlazada.add(new Persona("Wilfredo",17));
       enlazada.add(new Persona("Kelly",21));
       enlazada.add(new Persona("Javier",19));
       enlazada.add(new Persona("Christian",18));
       
       System.out.println("TAREA 3: LISTA ENLAZADA" + enlazada);
       
       //******************* 
       //Utilizar la clase Persona que implementa la interface Comparable con una lista LinkedList como la colección de objetos.
       //linkedlist con tipo genericos      
       LinkedList<Persona> listaLinked = new  LinkedList<Persona>();
       
       listaLinked.add(new Persona("Rosa",16));
       listaLinked.add(new Persona("Wilfredo",17));
       listaLinked.add(new Persona("Kelly",21));
       listaLinked.add(new Persona("Javier",19));
       listaLinked.add(new Persona("Christian",18));
       
       listaLinked.get(0);
       System.out.println("TAREA 4: LINKEDLIST : está implemetada en TAREA.java como 'PersonasLinked'");
       
              //Diccionario de palabras con int4erfaz map
       // Modificar la tarea 3 para que la lista enlazada de tipos genéricos implemente la Interface Iterator.
       
      
        List listaIt = new ArrayList();
        
        
        listaIt.add(new Persona("Marisol",16));
       listaIt.add(new Persona("Yamil",17));
       listaIt.add(new Persona("Javi",21));
       listaIt.add(new Persona("Maydana",19));
       listaIt.add(new Persona("Carlos",18));
       
        Iterator iterador = new PersonasIterator( listaIt.iterator() );
         System.out.println("TAREA 5: ITERATOR \n");
        while( iterador.hasNext() )
            System.out.println( iterador.next() );
        
         System.out.println("TAREA 6: Diccionario: Esta implementado en la clase TAREAdiccionario como un formulario \n");
        
        
        
       
       
       
       
       
    }
    
}
